import axios from 'axios';
import cacheManager from '../utils/cacheManager.js';

const BASE_URL = 'https://celestrak.org';

/**
 * 从网络获取TLE数据
 * @param {string} path - 卫星组路径
 * @returns {Promise<string>} TLE数据
 */
function getTleDataFromExternal(path = '') {
	let uri = `${BASE_URL}/NORAD/elements/gp.php?GROUP=${path}&FORMAT=tle`;
	return axios.get(uri).then((res) => {
		if (res.status === 200) {
			return Promise.resolve(res.data);
		} else {
			ElMessage.error('获取TLE失败');
			return Promise.reject(res.statusText);
		}
	});
}

/**
 * 获取TLE数据 - 优先从本地缓存获取，仅在无缓存时才自动更新
 * @param {string} path - 卫星组路径
 * @param {boolean} forceUpdate - 是否强制从网络更新
 * @param {number} maxAge - 缓存最大有效期（毫秒），默认24小时
 * @returns {Promise<string>} TLE数据
 */
async function getTleData(path = '', forceUpdate = false, maxAge = 24 * 60 * 60 * 1000) {
	try {
		// 如果不是强制更新，先尝试从缓存获取
		if (!forceUpdate) {
			const cachedData = await cacheManager.getTleData(path);
			if (cachedData) {
				// 如果有缓存数据，优先使用缓存（无论是否过期）
				if (!cacheManager.isTleDataExpired(cachedData, maxAge)) {
					console.log(`%c 使用有效缓存TLE数据: ${path}`, 'color:#0f0;');
					return cachedData.data;
				} else {
					console.log(`%c 使用过期缓存TLE数据: ${path}`, 'color:#ff9900;');
					return cachedData.data;
				}
			}

			// 仅在无缓存时才自动从网络获取
			console.log(`%c 无缓存数据，从网络获取TLE数据: ${path}`, 'color:#ff6600;');
		} else {
			// 强制更新时从网络获取
			console.log(`%c 强制从网络获取TLE数据: ${path}`, 'color:#ff6600;');
		}

		// 从网络获取新数据
		const data = await getTleDataFromExternal(path);

		// 保存到缓存
		await cacheManager.saveTleData(path, data);

		return data;
	} catch (error) {
		console.error(`获取TLE数据失败 (${path}):`, error);

		// 网络请求失败时，尝试使用任何可用的缓存数据
		const cachedData = await cacheManager.getTleData(path);
		if (cachedData) {
			console.warn(`%c 网络请求失败，使用缓存数据: ${path}`, 'color:#ff9900;');
			return cachedData.data;
		}

		throw error;
	}
}

/**
 * 更新指定卫星组的TLE数据
 * @param {string} path - 卫星组路径
 * @returns {Promise<string>} 更新后的TLE数据
 */
async function updateTleData(path) {
	return getTleData(path, true);
}

/**
 * 批量更新所有已缓存的TLE数据
 * @param {Function} onProgress - 进度回调函数 (current, total, groupName)
 * @returns {Promise<Object>} 更新结果统计
 */
async function updateAllTleData(onProgress) {
	const cachedGroups = await cacheManager.getAllCachedTleGroups();
	const results = {
		total: cachedGroups.length,
		success: 0,
		failed: 0,
		errors: []
	};

	for (let i = 0; i < cachedGroups.length; i++) {
		const group = cachedGroups[i];
		try {
			if (onProgress) {
				onProgress(i + 1, cachedGroups.length, group);
			}

			await updateTleData(group);
			results.success++;
			console.log(`TLE数据更新成功: ${group}`);
		} catch (error) {
			results.failed++;
			results.errors.push({ group, error: error.message });
			console.error(`TLE数据更新失败: ${group}`, error);
		}
	}

	return results;
}

/**
 * 获取缓存统计信息
 * @returns {Promise<Object>} 缓存统计
 */
async function getCacheStats() {
	return await cacheManager.getCacheStats();
}

/**
 * 清空所有TLE缓存
 * @returns {Promise<void>}
 */
async function clearAllCache() {
	return await cacheManager.clearAllTleData();
}

export { getTleDataFromExternal, getTleData, updateTleData, updateAllTleData, getCacheStats, clearAllCache };
